package com.wonderful.mall.search.thread;

import java.util.concurrent.*;

public class ThreadTest {
    public static ExecutorService service = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main start");

//        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
//            System.out.println("current thread: " + Thread.currentThread().getId());
//            int i = 10 / 2;
//            System.out.println("result: " + i);
//        }, service);

//        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
//            System.out.println("current thread: " + Thread.currentThread().getId());
//            int i = 10 / 2;
//            System.out.println("result: " + i);
//            return i;
//        }, service).whenComplete((res,exception)->{
//
//        });
//        Integer integer = completableFuture.get();
//        System.out.println(integer);

        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("current thread: " + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("result: " + i);
            return i;
        }, service).handle((res,thr)->{
            if (res!=0){
                return res*2;
            }
            if (thr!=null){
                return 0;
            }
            return 0;
        });
        Integer integer = completableFuture.get();
        System.out.println();
//        service.execute(new Runnable01());
        //1、corePoolSize：核心线程数；线程池创建好以后就准备就绪的线程数量，等待接受异步任务曲执行，线程池不销毁就一直存在
        //2、maximumPoolSize：最大线程数量；控制资源
        //3、keepAliveTime：存活时间，如果当前线程数量大于核心数量，释放空闲的线程（maximumPoolSize-corePoolSize），只要线程空闲大于指定的keepAliveTime；
        //4、unit时间单位
        //5、BlockingQueue<Runnable> workQueue：阻塞队列。如果任务有很多，就会将目前多的任务放在队列里面。只要有线程空闲，就回去队列里面取出新的任务继续执行。
        //6、threadFactory：线程的创建工厂。
        //7、handler如果队列满了，RejectedExecutionHandler handler 按照指定的拒绝策略拒绝执行任务
        /*
        运行流程：
                1、线程池创建，准备好 core 数量的核心线程，准备接受任务
                2、新的任务进来，用 core 准备好的空闲线程执行。
                (1) 、core 满了，就将再进来的任务放入阻塞队列中。空闲的 core 就会自己去阻塞队
                列获取任务执行
                (2) 、阻塞队列满了，就直接开新线程执行，最大只能开到 max 指定的数量
                (3) 、max 都执行好了。Max-core 数量空闲的线程会在 keepAliveTime 指定的时间后自
                动销毁。最终保持到 core 大小
                (4) 、如果线程数开到了 max 的数量，还有新任务进来，就会使用 reject 指定的拒绝策
                略进行处理
                3、所有的线程创建都是由指定的 factory 创建的。
         */

        //一个线程池 core:7 ; max:20 ; queue:50  100并发怎么分配
        //7个立即执行，50个进入队列，再开13个进行执行。剩下30个使用拒绝策略。
        //不想抛弃继续执行使用CallerRunsPolicy
//        ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
//                200,
//                10,
//                TimeUnit.SECONDS,
//                new LinkedBlockingQueue<>(100000),
//                Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy());
        System.out.println("main end,result:"+integer);
        service.shutdown();
    }

    public static class Runnable01 implements Runnable{

        @Override
        public void run() {
            System.out.println("current thread: "+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("result: "+i);
        }
    }
}
